An immutable objectis an object whose state cannot be modified after it is created. Immutable objects have several desirable properties, of which the two most important ones relevant to this post are:
They are inherently thread-safe: being read-only, they can be accessed safely from separate threads without having to worry about unexpected state or overwriting changes.
Therefore, it is common to implement objects as immutable, and software frameworks may require/expect polymorphic objects passed to their APIs to be immutable. Unfortunately, correctly implementing an object as immutable relies on the developer’s expertise in most mainstream OOP languages (it cannot be enforced by the programming language).
Data classes in Kotlin certainly simplify creating value objects: an equals, hashCode, and copy function are automatically generated. However, data classes are not immutable by default! Kotlin still allows defining var members on data classes, and adding members of mutable types.
True guarantees for immutability would have to be baked in to the programming language/compiler, or verified using a static checker. While proposals to support immutability in Kotlin exist, a fully functional static checker for Kotlin is already available—detekt.
Detekt contains a rule out of the box to verify whether all members in data classes are specified as val, but does not verify whether those members are immutable types. Furthermore, not all immutable objects should necessarily be implemented as data classes, and there might be cases in which mutability in data classes is desirable.
Having a need to enforce developers that extend base types in a framework I am working on as immutable and/or as data classes, I implemented a detekt plugin which enables verifying whether concrete classes are implemented as specified according to annotations applied to base types (e.g., @Immutable and @ImplementAsDataClass).
For example, the following implementation will warn NotImmutable is not implemented as immutable when running the static checker since Mutable.foobar is specified as var:
class Mutable( var foobar: Int )
class NotImmutable( val mutable: Mutable ) : Base
@Immutable
interface Base
Suppose you have a list of object instances (Kotlin’s concept for singleton classes) that are logically related to one another and you therefore want to group them together, but also want to provide direct (non-index- or iterator-based) access to them, similar to how you access an enum.
How would you go about doing that in Kotlin?
As an example, take the following DataType interface and implementing object Geolocation:
interface DataType { val typeName: String }
object GeolocationType : DataType
{
override val typeName: String = "geolocation"
fun create( longitude: Double, latitude: Double ) =
Pair( longitude, latitude )
}
Imagine many more DataType‘s: WeightType, StepcountType, etc. Now you want to provide a list of SupportedTypes containing all the types your codebase supports, but you also want to provide direct access to that list, so that the create() method (and other potential type-specific members) for Geolocation can be called.
While enums in Kotlin are fairly powerful—they largely behave like normal classes and can implement interfaces—they do not support generic type parameters and (as far as I could figure out) enum values cannot be instantiated based on existing instances. You could let the enum implement the interface of the instances you want to represent and override all methods redirecting them to the wrapped instance, but:
This introduces an intermediate instance, which might not be desirable for equality checking.
Does not provide access to type-specific members, such as create() in the example given.
Leads to heavy code bloat which is no fun to maintain.
enum class SupportedTypes : DataType
{
GEOLOCATION
{
override val typeName = GeolocationType.typeName
// This method can't be accessed!
fun create( longitude: Double, latitude: Double ) =
GeolocationType.create( longitude, latitude )
}
}
Instead, I opted to create the following base class …
open class EnumObjectList<T>
private constructor( private val list: MutableList<T> ) :
List<T> by list
{
constructor() : this( mutableListOf() )
protected fun <TAdd : T> add( item: TAdd ): TAdd =
item.also { list.add( it ) }
}
This now allows to iterate all supported types, just like enums or a list, but also to get the full type information (including generics) when accessing the member directly:
val supportedTypeNames = SupportedTypes.map { it.typeName }
val data = SupportedTypes.GEOLOCATION.create( 42.0, 42.0 )
Over a year ago I announced Socratrees, a platform to support online argumentative discussion.
Complex interrelations between different statements which make up an argument are often hard to follow, or hard to contribute to, when forced into a linear format. This is an unfortunate characteristic of essentially all modern media used to present arguments and host discussions. Socratrees offers an alternative by outlining arguments into intuitive hierarchies of supporting and opposing statements.
Our mission statement reads as follows:
Transparency first: our primary goal is not to find out who is right or wrong, but to improve transparency of thought.
Finding common ground: encourage consensus building, to build unity.
Inclusiveness: represent all opinions, also minorities and repressed groups.
Facilitate conducive discussions.
Inspire critical thinking.
Since the start of this month, the site is now in private beta during which we will evaluate how well our current design supports these goals and how it can be approved upon. This contributes to research on argument technologies. Join private beta and help us make discussions great again!
During the vision keynote at Microsoft Build 2018, Satya Nadella introduced the Microsoft 365 platform, a new technology which aims to improve the integration between different Microsoft products and devices (and even other vendors). As great as that is, the underlying motivation is much more interesting and reads like the introduction to a typical paper on activity-centric computing—a line of research originating in the 80s (referred to in my earlier writing as ‘activity-based computing’) which argues for an alternative to the current file-, window-, and application-dominated user interface paradigm.
During a single day you’re using multiple devices, you’re at multiple locations, working with multiple people, and interacting using multiple senses. That is the world we already live in. We need an operating system, we need a platform, that abstracts the hardware at that level, that creates an app model at that level. Single devices will remain important, but this ‘meta orchestration’ is what we need to do. We need to ‘up level’ even our concept of what an operating system is. And that is what Microsoft 365 does. – Satya Nadella, Microsoft Build 2018
This ‘meta orchestration’ is what research prototypes in activity-centric computing typically support by introducing ‘computational activities’ which can be managed by the user or inferred by the system, can be suspended and resumed, can roam across devices, and can be shared with others.
Activity-centric computing addresses deep-rooted information management problems in traditional application-centric computing by providing a unifying computational model for human goal-oriented ‘activity’, cutting across system boundaries. – Upcoming review on activity-centric computing.
Certainly, Microsoft is aware about activity-centric computing and has even contributed to it in the past (e.g., Scalable Fabric and Project Colletta). Even more, Satya starts the keynote by quoting Weiser who first introduced the term ubiquitous computing, a related and overlapping field of research.
The most profound technologies are those that disappear. They weave themselves into the fabric of everyday life until they are indistinguishable from it. – Mark Weiser, The Computer for the 21st Century
But, what is really exciting about this announcement is that this is the first time a major software company seems to embrace (and publicly announce) this as the future of computing. In the past, a research group at Apple Computer (including Donald Norman) has toyed with the idea, IBM has a suite of collaboration tools supporting activities, and some features (such as virtual desktops) have been slowly incorporated into most operating systems. But for activity-centric computing to truly succeed it needs to be integrated into the very fabric of computing. In research, most prototypes have largely been inhibited by having to build on top of the very infrastructure they set out to change. As I conclude in my PhD thesis on Task and Interruption Management in Activity-Centric Computing:
Norman and Verganti compare incremental innovation with radical innovation through the use of a hill-climbing analogy: “Incremental innovation attempts to reach the highest point on the current hill. Radical innovation seeks the highest hill”:
… [activity-centric computing] envisions a radically new computing paradigm incompatible with the current antiquated desktop metaphor for office work. Building activity-centric computing systems is a continuous uphill battle against an industry which is only trying to achieve local maxima. In contrast, activity-centric computing pursues radical innovation, aiming for one unifying global maximum.
With the introduction of Microsoft 365, Microsoft is taking its first steps towards a new infrastructure which could potentially host this new computing paradigm and its entailing principles.
The world’s applications going forward need a ubiquitous computing fabric from the cloud to the edge. They need a new app model that is distributed, event-driven, and serverless. – Satya Nadella, Microsoft Build 2018
This is reflected in some of the other announcements, such as live code sharing between Visual Studio and Visual Code (which in research we call ‘activity sharing’), application-less event handlers hosted using Azure functions and adaptive cards which can host content within other applications (decoupling of functionality and applications), but perhaps most clearly by how ‘computational activities’ will be represented in Windows 10 going forward.
With timeline, the basic idea is that the things that you do on your PC, or other devices, are available in a single click from the taskbar. You can scroll back through time, see everything you were working on, and just click to resume. Now, the key idea here though is that timeline is based on the Microsoft Graph and therefore it enables cross-device experiences [including iPhone browsing history]. – Joe Belfiore, Microsoft Build 2018
This history of the user’s interactions across devices are not in themselves ‘computational activities’. Computational activities require the ability for the user to aggregate disparate resources (managed by separate applications), such as web pages, Office documents, images, etc. This, Microsoft has decided to implement as what they call ‘sets’. In 2012 I discussed why traditional tabbed windows (managed by a single application) are inherently broken, and suggested how an implementation similar to ‘sets’ might lead to more scalable window management. With sets, all work related to a single ‘activity’ can be grouped under a single window using multiple tabs (regardless of the application used). More importantly, this ‘activity’ window can be closed without losing work and retrieved at a later moment in time when ready to resume work (which in research we call ‘activity suspend and resume’). Furthermore, this can even be done on a different device than where the work was first initiated (which in research we call ‘activity roaming’).
In my own research, I implemented similar features on top of Windows 7 in a system called ‘Laevo’, but in addition also looked at how activity planning and the handling of to-do items (traditionally supported by electronic calendars) can be integrated with such ‘computational activities’ or ‘sets’; why duplicate the effort of managing items in a calendar when they are already represented as activities?
Most of the time spent implementing such novel new systems is on ‘hacking’ the operating system and applications you intend to support to become ‘activity-aware’, and building a distributed ‘activity model’ which different devices can use to show and resume activities. With Microsoft Graph, Microsoft is building the necessary distributed infrastructure to start building such ‘activity models’ and is encouraging application developers to integrate with it; an essential step towards moving activity-centric computing from ‘the lab’ into production.
It thus seems Microsoft is finally implementing activity-centric computing as it was first envisioned in 1986 by Yoshiro Miyata and Donald A. Norman, targeting radical innovation as opposed to incremental innovation. There is still a long way to go towards incorporating other aspects of the original conceptualization of personal computing (as demoed by Alan Kay in the video below), but this is definitely a step in the right direction!
Alan Kay giving a demo of what commercial personal computers (unfortunately) did not turn out to be: https://t.co/hKybCLJ8ME
At the Build 2017 conference, Microsoft revealed upcoming changes to the way applications will be (and can be) designed, introducing their Fluent Design System in the Windows 10 Fall Creators Update. This update focuses on the role which light, depth, motion, material, and scale can play in the design of user interfaces (UIs): really nice and impressive stuff which can certainly be used to improve user experiences. However, given that it has been a recurring theme in UI design to prioritize aesthetics over usability, I want to take a critical look at one of the newly introduced features—reveal highlight.
Reveal uses light to make interactive elements stand out. Light illuminates the interactive element the user can interact with, revealing hidden borders. The light also gently illuminates other interactive elements that are nearby.
… The Reveal behavior does this by revealing the clickable content’s container when the pointer is nearby.
Certainly an improvement, but at this point I feel it is worthwhile to take a couple more steps back to compare this with what the calculator looked like in Windows 7.
Less pretty, to be sure, but notice in particular how there is no need to hover over the memory buttons to perceive that they can be clicked and where to do so. To me, the UI modifications introduced as part of Windows 8 and 10 are two steps back and ‘reveal’ is one step forward, mitigating some of the earlier mistakes: the power of perceived affordances took a backseat to ‘flat design’, effectively stripping many UI elements of their clarity in how they can be used: where to click, can they be clicked, and what type of element it is. The question I would like to ask is: Should buttons ever look like ordinary labels in the first place?
While it is awesome to have additional development tools available to create more pleasing ‘on hover’ effects, conceptually this is nothing new. From a design perspective, it would still not make sense to require a user to hover over important UI elements to only then be able to interpret what they are. Therefore, at this point I would merely like to highlight that ‘reveal’ with the purpose of revealing functionality should likely be used sparingly, only for non-essential user interface elements. Whether or not the memory buttons in the calculator are ‘important’ (and potential alternate ways of visualizing them) is a different discussion to be had.
As researchers in user interface design know, perceived affordances improve usability. Conversely, I blogged about how the lack of affordances in the window manager of Windows 10 complicates resizing and moving windows around. Ironically, this was demonstrated perfectly by Ashish during his presentation on how to use the Fluent Design System features in XAML, as he spent 32 seconds on resizing a window to its desired size while narrating “Sorry. If this machine cooperates.” and Tim helpfully instructing him that he is “anchoring [the window] too high …”.
The (literal) bottom line of this post: great new stuff in Windows (and XAML), but I hope this post serves as a warning to think of usability first when using the new Fluent Design System features, aesthetics only second.
There is one upside to the recent election of president Donald Trump (yes, the title of this post is a pun) and the earlier withdrawal from the European Union by the UK: it has become a whole lot easier for me to pitch an idea which I’ve been advocating (with some opposition) for nearly a decade now. It is my hope that the project I’m announcing in this post will help fight fake news—possibly the main driving force behind these events.
Given the growing body of knowledge accumulated by mankind, most professions require an extreme degree of specialization. Nowadays, you can be the most knowledgeable person on one topic while simultaneously being the most ignorant when it comes to another. Yet, society seems to expect us to have an opinion on everything impacting our daily life, from climate change to immigration issues, regardless of whether or not we have a comprehensive understanding of the topic at hand. This is where media comes in, which is supposed to keep us up to date and well-informed.
However, there is a problem with modern media. Although today we can access more information, faster than ever before, we are still left to our own devices when it comes to judging how relevant or valid this constant stream of data is. Finding information is easy (and even hard to ignore), but evaluating it is more difficult than ever. Consequently, most of us rely on whatever sources we deem authoritative and form our opinions based on that. The current prevalence of misinformation and fake news indicates this poses a risk, but as I will argue here, is merely symptomatic of a larger underlying problem.
The different media we use today to share knowledge and host discussions unnecessarily segregate opposing views. For example, this blog post makes the case for an alternative medium for discourse, but the only way to contest parts of the containing argumentation (although overall you might agree) is by writing a reply in the comments section (separated from the main article). Only through a fair amount of clarification (e.g., by referring to certain sentences within the article) will it be made clear how your comments relate to the overall blog post and might we be able to carry forward a fruitful discussion. As you have likely experienced, similar discussions can easily turn into stressful conflicts (both online and in real life discussions). But why should this be so?
Debaters on comprehensive scientific problems are … like lawyers who have to take a side. Each of them intends to strengthen his own arguments and to weaken the arguments of the aggressor—but no judge is in the chair. … Finally we find ourselves all together in the same ship and are co-operating even when we think we are fighting one another.
— Otto Neurath (1940), “Universal jargon and terminology.”
Discussions are inherently collaborative. As opposed to lectures, during which information is handed to you on a platter, discussions encourage you to share your own world views. Naturally, this gives rise to disagreement; if we were all like-minded, conversations would be rather dull (in fact, there would be no discussion at all). However, disagreement should not be seen as conflict but rather as an opportunity to learn; a chance to explore and understand perspectives different from yours. Unfortunately, it is all too common to fall into the trap of turning a discussion into a lecture; to start preaching your own world views without seeking to understand those of others. But if your goal is truly to convince someone, it is all the more important to seek out common ground first. The ideal argument is tailored to the person you are talking to, not merely an elaborate summary of what you know. In short, a conducive discussion should be as much about listening as it is about talking.
As such, having a one-on-one discussion is difficult enough as is, but trying to do the same online (a medium everyone has access to) is near impossible. Unless the medium is designed with large-scale discussion in mind! A linear format is incapable of expressing the underlying complex structure of argumentation with multiple opposing views. It is up to the reader to mentally connect the different statements which make up a discussion, to find out how they contribute to a larger topic, and to understand which conclusions can be drawn from them.
For the past few years I have had a vision on how to improve discussions and argumentation on the internet (based on my experience with the extremely successful network of Q&A sites: Stack Exchange). Countless brainstorming sessions and reading on the side later have eventually culminated into the design of a social network website, Socratrees, currently under active development.
Introducing Socratrees: The Socratic Tree of Knowledge
Complex interrelations between different statements which make up an argument are often hard to follow, or hard to contribute to, when forced into a linear format. This is an unfortunate characteristic of essentially all modern media used to present arguments and host discussions. Socratrees offers an alternative by outlining arguments into intuitive hierarchies of supporting and opposing statements. This design is loosely based on argumentation theory. However, we do not expect you to be familiar with theory in order to start using Socratrees.
Over the next couple of months I will start announcing specifics and open up parts of the project to the public. When interested, you can already sign up for private beta which gives you an exclusive opportunity to help shape this project from the very beginning! Until then, we welcome any questions, ideas, or feedback on our dedicated subreddit.
“Listening and responding to customers is so basic and fundamental. The emergence of social media elevates how companies can act on the feedback they get from customers,”
First, let’s resolve some of that pent up anger you might have through comic relief. After my experiences with Dell I could not help but notice the similarity between the Dell logo and the multi-national conglomerate in the television series Mr. Robot—Evil Corp.
Or how aptly the Veridian Dynamics commercials in Better Off Ted seem to portray Dell’s business strategy.
People lie. Companies protect their interests. It’s different.
Right and wrong. It means something. We just don’t know what.
Comedy aside, scouring the net for customer dissatisfaction with Dell reveals just how close to the truth this satire gets. As explained in a follow-up article in 2005 to a viral post by Jeff Jarvis, “Dell lies. Dell sucks.” (having a measurable impact on Dell’s reputation), Jeff explains:
I learned some time ago that you can search Google for any brand, followed by the word “sucks”, to find out just how much ill will is attached.
It is now 2016. I decided to do some investigative journalism to find out how common the problems I encountered with my first ever Dell purchase are. Inspired by Jarvis, the two graphs below depict google hits (corrected for yearly revenue) for each of the major laptop brands. Dell ‘only’ takes second place when querying whether a company sucks, but takes the lead in being the most hated.
Investigating where this hatred comes from requires a more thorough analysis of Dell’s customer support, which I have ample of experience with after three months of continued hardware and software issues using my XPS 15 9550. For a 2142-dollar laptop (€1944) one expects (and pays for) a swift resolution when the device becomes inoperable, as opposed to three months which pass before receiving a functioning laptop (¼th of the warranty). The reality is thus different entirely, and borders on the absurd. The following summary is based on personal anecdotes, but many similar horror-stories are scattered online.
Dell support is slow, reallySLOW: the three months it took Dell to get me a full replacement is testimony of this, but even the most basic steps towards this goal take weeks. After Dell agreed to a full replacement, it took 17 days before the new order was placed. This includes seven workdays just to send me the specifications of the new laptop; essentially a copy/paste (which coincidentally they got wrong the first time around).
Dell support does not know, or own, its own products: I spent several hours on the phone to explain that the flashing battery light indicator on the front of the laptop indicated my battery was no longer working, as per their own documentation. Dell support does not have working laptops by hand; they fully rely on debugging your machine remotely.
Dell firmware incapacitates its high-end hardware: the BIOS, drivers, and other firmware (e.g., PremierColor, offering true-to-life colors for their flagship monitors) is some of the most bug-ridden, untested, undocumented, software I have ever encountered. Support simply recommended me to uninstall PremierColor, as well as to revert to an older BIOS version. A BIOS update released to resolve a particular issue with the monitor instead exacerbated it. To date (three updates and several months later) this erroneous fix remains unaddressed, and the common resolution of rolling back to an older BIOS version remains unacknowledged by support.
Dell is unaware, or acts ignorant, about issues reported by users: many users seek support on the Dell community, which unfortunately is almost devoid of Dell employees. Nonetheless, there is more valuable information to be found here (including resolutions such as reverting to the older BIOS version) than by contacting Dell support.
Dell is wasteful: in total UPS delivery has shown up at my doorstep six times, while Dell was fully aware I was not at home or not ready to deliver a package on these specific dates.
Dell pursues the minimum support required: although Dell boasts about its premium support with “[o]nsite service after remote diagnosis within 1-2 business days”, the reality is Dell requires you to spend an entire day on the phone to establish you have a broken battery, several days to ship you a new battery (for which you need to be at home for delivery), expects you to have the necessary torque screwdrivers to replace the battery yourself, and requires you to spend another day at home to await pickup of the old broken battery.
Dell upper management does not take responsibility: Dell tries its very best to keep you entertained with first-line technical support; unfortunate lackeys who are mainly paid to divert your attention away from Dell’s upper management. Dissatisfaction with delays in technical support is redirected to customer care, which in turn redirects you back to technical support. Social media support is a facade put up to give the impression that @DellCares, but in reality is just another middleman pointing back to technical support.
Review Dell’s terms & conditions (this might differ depending on your point of sale, but the following gives an indication of things to be aware about):
Under warranty, Dell has to refund or repair the product, but will not provide any further compensation (e.g., consequential damages or unavailability of the product).
Warranty won’t be extended when the product is replaced or repaired.
Dell will send parts or provide an engineer service only if it has been established that the problem cannot be solved by recommended troubleshooting procedures (except when you have special needs). (From Dell’s European Collect and Return Service)
No warranty is provided for Dell software. Dell only commits to delivering the software regardless of whether it works or not (e.g., PremierColor).
At first sight this paints a grim picture where Dell can provide ‘support’ indefinitely until the warranty runs out, regardless of the state the product is in. I am skeptical of this; it seems highly unlikely Dell could sell you a cardboard box claiming it to be a laptop, ‘fixing’ it for just as long as the warranty lasts. Therefore I am currently pursuing a complaint requesting compensation based on the Consumer Terms of Sale:
(12 A) Either party may terminate this Agreement (i) if the other party commits a material breach which is not cured within 30 days of written notice or (ii) if the other party ceases, or threatens to cease, to carry on business or becomes insolvent.
I claim Dell has failed to deliver me a functioning laptop within 30 days, and gave them notice of this breach. In my specific case, I have not had a ‘laptop’ in the true sense of the word for over three months, since I had no functioning battery requiring the device to remain plugged in to an external power source at all times.
Whether or not you want to pursue your inquiry with Dell to this extent, I can provide you with a couple of concrete tips based on my experience with technical support and my reading of the terms of sale:
Take pictures and videos of erroneous behavior, and write down error codes: for straightforward hardware issues with laptops, run Dell’s Preboot System Assessment and note down error codes prior to contacting Dell.
Avoid phone support: not only is phone support painstakingly slow (spelling service tags, error codes, and starting all over when redirected), if you ever want to pursue your issues with Dell, you need a written notice of the problems you encountered.
If a refund or replacement is taking too long (or is denied), don’t wait too long before filing a complaint through an external party defending your rights: citizens of Canada and the United States can do this for free through Better Business Bureau (BBB). European citizens might have luck finding a similar service through Online Dispute Resolution. Dell seems proud of their BBB statistics, which includes resolutions within a month, but fails to consider that the majority of customers do not know about BBB. Furthermore, Dell seemingly sees no harm in wasting weeks of customers’ time, requiring them to talk to technical support during work hours.
Consider the advantage of a full refund over a complete product replacement, in particular when nearing the end of your warranty. Using a full refund the same product can be purchased, effectively renewing your warranty.
How company management can ruin product quality and customer support
We are stuck with support when what we really need is a product that works.
Dell support is primarily about appearances, not results. To exemplify, the report on how to listen and engage in the digital marketing agecommissioned by Dell in 2011, is focused primarily on influencing customer’s perception (think pointless endeavors like @DellCares), not around resolving actual issues reported by customers:
“I believe the greatest benefit has been that our customers who use social media and interact with our efforts see us as a more progressive company because we are using multiple channels for communicating.” — Marketer at enterprise banking company
Corporate management has put in place a support system which might look good on paper, but fails miserably from the consumer’s perspective. Dell’s hierarchical company structure, comprising several departments each focusing on their respective tasks, each adhering to strict workflows and predefined communication channels, has resulted in a company which can hardly communicate internally, let alone, communicate effectively with customers in a timely manner. As derogative as this sounds, this is based (again) on personal anecdotes collected over the past three months. Although I did attempt to request more detailed information from Dell, they unfortunately did not reply:
Communicating technical issues reported by customers resembles a game of Chinese whispers, where front-line support distorts and filters information prior to redirecting it to the engineering department. No direct communication with qualified engineers seems possible, regardless of the amount of technical details the end-user provides.
Known issues are not communicated internally (or at least not effectively). For example, widespread public feedback on erroneous firmware releases goes unanswered. Instead, hardware replacements are sent out for issues which have long since been identified to be software-related.
Technical support and customer support are two separate departments which do not communicate internally. It is up to the customer to reach out to both, restating the problems they encountered. That said, I have yet to find out what purpose customer support serves, more than redirecting you back to technical support.
Internal communication within Dell slows down to a crawl since everybody needs to report to somebody higher up. In the end, nobody takes responsibility and the only way for consumers to get things done (in a timely manner) seems to be by filing a complaint through an external organization.
In short, the best way to get Dell support ironically seems to be to spend as little time as possible talking to Dell support. Instead, once Dell has failed to deliver you a functioning system within 30 days (or sooner), immediately proceed with a complaint through an external organization requesting a full refund or replacement system. Hopefully, through this writing, Dell becomes aware of the shortcomings in their support system, and can start working towards improving customer support so that less drastic measures are required in the future.
A bit of a rant today, for which I apologize in advance.
So far, I have always been quite pleased with Microsoft Connect. As a bug reporting platform for Microsoft, I am under the impression that most issues are given professional consideration, even though they might go unanswered in the long run. The Microsoft Community on the other hand—the only place to submit bug reports concerning the Windows operating system—is a joke. One can not help but feeling treated like an average chum when an underpaid overseas employee ‘answers’ your question by posting a suggestion along the lines of:
In other words, the Microsoft Community is a help desk, tailoring to problems which can be solved by pointing to documentation, or posting a friendly reminder to update your computer, rather than a bug reporting platform. Perhaps justifiably, I got angry when trying to report on a recent issue with my new XPS 15:
No, the above ‘recommendation’ is not helpful. In fact, although I am certain your intentions are well, it even comes across as offensive. Please let me clarify why, and why you (or rather, Microsoft) might want to reconsider how bug reports for the Windows operating system currently work.
As part of my workday (as a software engineer), I took time off to report on a bug which could help out further development on a product I use every day as part of my work (the Windows operating system). I know pinpointing bugs can be hard, and detailed bug reports are hard to come by. Therefore, I figured sharing my findings could help out anyone working on this product by either making them aware there is a problem, or by pinpointing where the problem in particular might lie. Consider it free labor on my behalf, because I care about the product which makes up my everyday work environment. I do the same whenever I encounter problems with Visual Studio, and every other product I rely on. To this end, I have had great experiences with Microsoft Connect; as a counterexample to the ‘Microsoft Community’ here, I feel the Visual Studio team takes feedback from the community seriously, provides timely feedback, and iteratively improves on the overall product based on community interaction.
Unfortunately, such a ‘community’ seems to be non-existent for Microsoft Windows. As if possessed with magical foresight, I was warned this “community is crap” and I should expect nothing but “crappy unhelpful ‘suggestions’ which after about a week or so are enforced as the accepted answer by moderators”. Please let this sink in for a moment: this is the impression that professionals that try to contribute to this community (and Windows) are left with after posting. Sure, they won’t report on any more bugs; do you believe this means they are solved? More likely, the product or particular feature reported on is abandoned altogether.
This is where you, Sayan, come in. An unfortunate employee of Microsoft, hired to post anything remotely related from the documentation, seemingly assuming any question on this site must be posted by a granny that just received her first tablet computer for her 75th birthday. Unfortunately this also means you are now the one being bombarded with this wall of text, for which I apologize. Feel free to redirect this to whoever ‘higher-up’ believes they are providing good ‘product support’ for Windows.
It is a bit hypocritical to pester people with pop-ups requesting automated bug reports each time a crash occurs, or requesting people to enable application reporting ‘to improve your experience’, but seemingly disregard any detailed feedback people provide voluntarily. Why is there no professional, public, bug reporting site for Windows?
…
For now I have disabled this “setting[ ] which adds to its beauty”, since I can obviously not expect my newly purchased >2000 dollar laptop to handle it. If you believe this means my question is answered, by all means mark it as such. Alternatively, if this bug report inspires your curiosity and you require more information in order to pinpoint the exact problem, I am more than willing to cooperate. I hope I provided you with sufficient information to run a repro on your end. I already ran two. ‘Helpful’ would be taking this bug report seriously, and you (Microsoft) doing the same.
Why does Microsoft (apparently deliberately) block off bug reports by professionals? They could easily set up Microsoft Connect to welcome Windows bug reports. Even without the developers looking into those issues directly, I feel by merely opening such a site up to the community better support than what currently is provided can be achieved. Cutting off such ‘volunteer’ testers is a big missed opportunity by Microsoft.
“What are adventure games?”, you might ask. When confronted with this question I usually reply they are interactive movies, where you need to solve puzzles in order for the plot to progress. As you interact with objects and characters within the game, the backstory is revealed. The first few minutes of Resonance provide a good first impression of what a point ‘n click adventure game has to offer: captivating cutscenes, followed by seemingly trivial interactions with the game environment, which regardless reveal a rich underlying story.
Example of a point ‘n click game (Resonance), where the player needs to interact with objects in the game environment in order to progress the plot.
Adventure games have gone somewhat out of fashion over the years, making way for more fast-paced action-packed video games, like first-person shooters. However, a few—mainly independent—developers have kept the genre alive, and true gems (like Resonance) are still released sporadically. They generally adhere to the core game mechanics (as well as witty dialogues) introduced by the classics, and often still prefer old school pixel artwork over modern graphics.
One overlooked feature of adventure games is they are inherently suitable to be played by multiple players;not true multiplayer, but for the lack of a better word, lets call them potential ‘audience games’. At countless occasions I have invited friends over to kick back in the couch, open a beer, and gaze at a projection or screen as somebody point ‘n clicks his way through the game’s narrative. Similar to watching a movie, but different in that shouting throughout (to point out what to click next) is not only appreciated, but in fact encouraged. There is something suspiciously entertaining about listening to people’s concoctions on what item to combine with the “rubber chicken with a pulley in the middle” in order to finally put it to good use; usually followed by a short silence and a subsequent “Why on earth would you want to do that?”. I dubbed such evenings (and late nights) ‘Adventure Game Nights’, and wanted to report on what works and what does not. In addition, I see opportunities for making adventure games true multiplayer experiences.
After years of hosting such events for uninitiated and seasoned players alike (I once even played a game over Skype), some things became apparent:
It is best to pick games with a strong narrative, rather than a shallow story line. In other words, games like Resonance, The Inner World, Still Life, and The Blackwell Legacy appeal to a wider audience than true classics like Monkey Island. Games on the far end of this spectrum, interactive dramas like The Walking Dead, are the perfect gateway drug for people to get hooked on the genre, but unfortunately lack the complexity which make adventure games stand out.
Spoken dialogues are essential! It is near impossible to stay focused as a group when everyone needs to read on-screen text at their own leisure and pace.
If you cherish your night rest, start early, and pick a game which doesn’t last too long (aim for a maximum of seven hours). Short episodic adventure games offer a solution, although they generally aren’t as captivating (the Blackwell series being the exception). Ideally, in case you have a core group of point ‘n click addicts, you can decide on a longer game and play it over several evenings.
Pixel hunting (scrutinous scanning of the screen to find anything clickable) is exacerbated when playing in group; you’ll hear people shouting “Can you click on the red thingy in the bottom corner?”, at times followed by “We already clicked that!”. A quick primer on how to tell whether something is clickable or not in advance is recommended.
The takeaway message for game designers and developers is there might be a broader audience for point ‘n click adventure games than they traditionally anticipate. Rather than solely tailoring adventure games to single player experiences, there is an opportunity to design adventure games with group experiences in mind. Besides changing the overall format so it can be consumed in one sitting (similar to movies), it would be worthwhile experimenting with features which account for multiple players wanting to interact with the game environment simultaneously. To this end designers could leverage the fact that players each carry a powerful computer in their pockets (smartphones) allowing for rich interactions. Some obvious candidates: maintain a history of interactions and dialogues, ‘vote to skip’, suggested puzzle resolutions including a point system, …
The possibilities are endless … A multiplayer point ‘n click game is long overdue!
A common solution to treating a generic type as non-generic is to implement an interface or make the generic type extend from a non-generic base class. Among other reasons, this allows you to instantiate a collection of generic types. There are varying implementations of this pattern, but they all seem to share this common strategy. In this article I present an alternate approach favoring composition over inheritance which I argue is more appropriate in circumstances where the intent is to break type safety.
To clarify, I will follow Steven Lowe’s argumentation on misuse of inheritance. Semantically, the statement “SomeType<T> is SomeType” is not always true; SomeType<T> is not a proper subtype of SomeType when the base type exposes type-specific bits (as Jon Skeet puts it). In this case the extending type imposes more restrictions than the base type. When there is a need to expose type-specific bits (implying type casts are involved), using inheritance does not follow the Liskov substitution principle (LSP). Regardless, such subtypes seem common. Just consider Microsoft’s List<T> implementing a non-generic IList which to quote Eric Lippert, “is a bit odd, since List for any type other than object does not fulfill the full contract of IList”.
From this it becomes clear there are real-world scenarios where a generic type needs to be accessed in a non-generic way (e.g. during reflection as I argued previously). Type safety is temporarily broken, leaving it is up to the caller to guarantee only the correct types are used. How then to improve on the following common implementation? Note that since the non-generic interface is implemented explicitly, the caller consciously needs to cast to ISomeType, somewhat alleviating the problem of possible misuse.
public interface ISomeType
{
object Value { get; set; }
}
public class SomeType<T> : ISomeType
{
public T Value { get; set; }
// Explicit implementation (cast to ISomeType needed to be used).
object ISomeType.Value
{
get { return this.Value; }
set { this.Value = (T)value; }
}
}
We need a non-generic interface but are given a generic interface, so why not apply the adapter pattern?
An adapter helps two incompatible interfaces to work together. […] Interfaces may be incompatible but the inner functionality should suit the need.
Since the class we are trying to create an adapter for is generic, our adapter implementation needs to be generic too. However, we can expose the non-generic interface which will be used by the client. Just like a usual adapter, the non-generic wrapper contains the adaptee and refers all of the IAdaptor calls to it, casting to T where necessary.
public interface IAdaptor
{
object Value { get; set; }
}
class NonGenericWrapper<T> : IAdaptor
{
private readonly Adaptee<T> _adaptee;
public NonGenericWrapper(Adaptee<T> adaptee)
{
_adaptee = adaptee;
}
public object Value
{
get { return _adaptee.Value; }
set { _adaptee.Value = (T) value; }
}
}
Furthermore, to facilitate the creation of this non-generic wrapper (and in addition hiding its implementation) the wrapper can optionally be initialized from within the adaptee and added as a member. This approach seems similar to how user interface controls in .NET expose the window handle they operate on as a member variable, allowing for unsafe operations when the control class does not offer the required functionality.
public class Adaptee<T>
{
public T Value { get; set; }
public IAdaptor NonGeneric { get; private set; }
public Adaptee()
{
NonGeneric = new NonGenericWrapper<T>(this);
}
}
Pattern which can be used to expose a non-generic interface from within a generic class.
This approach still requires boiler-plate code to be written and maintained (NonGenericWrapper<T>), but no longer breaks the Liskov substitution principle. Ideally creating non-generic wrappers can be automated, of which I created an early prototypical solution before (not functional in all scenarios). Until then, this solution provides a more robust implementation for complex scenarios using generics, like collections of generic types with varying type parameters on which the same operations need to be performed. This might be the topic of a future post.
There is something suspiciously entertaining about listening to people’s concoctions on what item to combine with the “rubber chicken with a pulley in the middle” in order to finally put it to good use; usually followed by a short silence and a subsequent “Why on earth would you want to do that?”. I dubbed such evenings (and late nights) ‘Adventure Game Nights’, and wanted to report on what works and what does not. In addition, I see opportunities for making adventure games true multiplayer experiences.
whatheco.de 